/**
 * 将包含parentId的flat结构数组,转换为携带children属性的树形结构数组
 * @param {array} ary
 * @returns 树形数组
 */
export function flatToTree(ary, key = 'itemId') {
  const map = new Map();
  const roots = [];

  for (const item of ary) {
    map.set(item[key], item);
  }

  for (const item of ary) {
    const parent = map.get(item.parentId);
    if (parent) {
      parent.children = parent.children || [];
      parent.children.push(item);
    } else {
      roots.push(item);
    }
  }

  return roots;
}

/**
 * 通过浏览器弹出下载文件保存二进制内容
 * @param {Uint8Array} data   二进制内容
 * @param {*} options          options
 */
export function saveBlob(data, { mimeType, filename }) {
  const blob = new Blob(data.map((buf) => Uint8Array.from(buf.data).buffer), { type: mimeType });
  const objectUrl = URL.createObjectURL(blob);
  const link = document.createElement('a');
  link.href = objectUrl;
  link.setAttribute('download', filename);
  document.body.appendChild(link);
  link.click();
  window.URL.revokeObjectURL(link.href);
  link.remove();
}

export function flattenObject(obj, prefix = '', valueHandler) {
  const flatObj = {};

  for (const key in obj) {
    // eslint-disable-next-line @iceworks/best-practices/recommend-polyfill, no-prototype-builtins
    if (obj.hasOwnProperty(key)) {
      const value = obj[key];
      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
        let nestedObj = valueHandler?.(value, key);
        if (nestedObj !== undefined) {
          flatObj[`${prefix}${prefix ? '.' : ''}${key}`] = nestedObj;
          continue;
        }
        nestedObj = flattenObject(value, `${prefix}${prefix ? '.' : ''}${key}`);
        Object.assign(flatObj, nestedObj);
      } else {
        flatObj[`${prefix}${prefix ? '.' : ''}${key}`] = value;
      }
    }
  }

  return flatObj;
}

/**
 * 接受一个数组和指定的字段  实现去重
 * @param {*} params
 * @param {*} key
 * @returns 去重后的数组
 */
export function uniqueUsingMap(params, key) {
  if (Array.isArray(params)) {
    const map = new Map();
    const uniqueArray = [];
    params.forEach((item) => {
      if (!map.has(item[key])) {
        map.set(item[key], true);
        uniqueArray.push(item);
      }
    });
    return uniqueArray;
  } else {
    throw new Error(`${typeof (params)} 不是一个数组!`);
  }
}

/**
 * 字符串转换成数字，初始化地图坐标使用
 * @param {*} params
 * @returns
 */
export function strTransferNumber(params) {
  const temp = params || '';
  if (!temp) {
    // 默认值，防止报错
    return {};
  }
  const [_lat, _lng] = temp.split(',');
  return {
    lat: Number(_lat),
    lng: Number(_lng),
  };
}

/**
 * 地图属性解析返回location拼接字符串
 * @param {*} obj
 * @returns
 */
export function deconstructionMapObj(obj) {
  const tempObj = obj || {};
  const { lat, lng } = tempObj;
  return `${lng},${lat}`;
}

/**
 * 数组转换成对象，初始化地图坐标使用
 * @param {*} arr
 * @returns
 */
export function arrTransferObj(arr) {
  const temp = arr || [];
  const [lng, lat] = temp;
  return {
    lat,
    lng,
  };
}

/**
 * 数组转换成字符串，组件提供给地图使用
 * @param {*} arr
 * @returns
 */
export function arrTransferStr(arr) {
  const temp = arr || [];
  const [lng, lat] = temp;
  return `${lng},${lat}`;
}

/**
 * 字符串转化成数组
 * @param {*} arr
 * @returns
 */
export function strTransferArr(str) {
  const temp = str.split(',');
  return temp;
}
